home *** CD-ROM | disk | FTP | other *** search
/ Champak 40 / Vol 40.iso / games / ufo_comm.swf / scripts / DefineSprite_48_ufo2 / frame_115 / DoAction.as
Encoding:
Text File  |  2007-04-25  |  64.8 KB  |  1,474 lines

  1. var ┬º\x01┬º = 658;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 658)
  6.    {
  7.       set("\x01",eval("\x01") - 40);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.    }
  11.    if(eval("\x01") == 787)
  12.    {
  13.       set("\x01",eval("\x01") - 359);
  14.       if(┬º┬ºpop())
  15.       {
  16.          set("\x01",eval("\x01") - 224);
  17.       }
  18.       continue;
  19.    }
  20.    if(eval("\x01") == 618)
  21.    {
  22.       set("\x01",eval("\x01") - 328);
  23.       if(┬º┬ºpop())
  24.       {
  25.          set("\x01",eval("\x01") + 81);
  26.       }
  27.       continue;
  28.    }
  29.    if(eval("\x01") == 986)
  30.    {
  31.       set("\x01",eval("\x01") - 291);
  32.       if(┬º┬ºpop())
  33.       {
  34.          set("\x01",eval("\x01") - 54);
  35.       }
  36.       continue;
  37.    }
  38.    if(eval("\x01") == 957)
  39.    {
  40.       set("\x01",eval("\x01") - 170);
  41.       ┬º┬ºpush(true);
  42.       continue;
  43.    }
  44.    if(eval("\x01") == 825)
  45.    {
  46.       set("\x01",eval("\x01") - 568);
  47.       if(┬º┬ºpop())
  48.       {
  49.          set("\x01",eval("\x01") + 48);
  50.       }
  51.       continue;
  52.    }
  53.    if(eval("\x01") == 204)
  54.    {
  55.       set("\x01",eval("\x01") + 621);
  56.       ┬º┬ºpush(true);
  57.       continue;
  58.    }
  59.    if(eval("\x01") == 404)
  60.    {
  61.       set("\x01",eval("\x01") + 582);
  62.       ┬º┬ºpush(true);
  63.       continue;
  64.    }
  65.    if(eval("\x01") == 371)
  66.    {
  67.       set("\x01",eval("\x01") + 116);
  68.       ┬º┬ºpush(true);
  69.       continue;
  70.    }
  71.    if(eval("\x01") == 428)
  72.    {
  73.       set("\x01",eval("\x01") - 224);
  74.       while(true)
  75.       {
  76.          if(eval(┬º┬ºpop()) == 572)
  77.          {
  78.             set("\x01",eval("\x01") - 98);
  79.             if(┬º┬ºpop())
  80.             {
  81.                set("\x01",eval("\x01") - 250);
  82.             }
  83.          }
  84.          else if(eval("\x01") == 224)
  85.          {
  86.             set("\x01",eval("\x01") + 181);
  87.             ┬º┬ºpush(true);
  88.          }
  89.          else
  90.          {
  91.             if(eval("\x01") == 474)
  92.             {
  93.                set("\x01",eval("\x01") - 250);
  94.                break loop0;
  95.             }
  96.             if(eval("\x01") == 329)
  97.             {
  98.                set("\x01",eval("\x01") + 375);
  99.                ┬º┬ºpop() >>> (┬º┬ºpop() >>> ┬º┬ºpop()) extends ┬º┬ºpop();
  100.                ┬º┬ºpop() extends {};
  101.                break loop0;
  102.             }
  103.             if(eval("\x01") == 451)
  104.             {
  105.                set("\x01",eval("\x01") + 29);
  106.                prevFrame();
  107.                break loop0;
  108.             }
  109.             if(eval("\x01") == 986)
  110.             {
  111.                set("\x01",eval("\x01") - 657);
  112.                if(┬º┬ºpop())
  113.                {
  114.                   set("\x01",eval("\x01") + 375);
  115.                }
  116.             }
  117.             else
  118.             {
  119.                if(eval("\x01") == 355)
  120.                {
  121.                   set("\x01",eval("\x01") - 224);
  122.                   break loop0;
  123.                }
  124.                if(eval("\x01") == 652)
  125.                {
  126.                   set("\x01",eval("\x01") + 156);
  127.                   if(┬º┬ºpop())
  128.                   {
  129.                      set("\x01",eval("\x01") - 670);
  130.                   }
  131.                }
  132.                else
  133.                {
  134.                   if(eval("\x01") == 808)
  135.                   {
  136.                      set("\x01",eval("\x01") - 670);
  137.                      break loop0;
  138.                   }
  139.                   if(eval("\x01") == 405)
  140.                   {
  141.                      set("\x01",eval("\x01") + 592);
  142.                      if(┬º┬ºpop())
  143.                      {
  144.                         set("\x01",eval("\x01") - 791);
  145.                      }
  146.                   }
  147.                   else if(eval("\x01") == 138)
  148.                   {
  149.                      set("\x01",eval("\x01") + 31);
  150.                      ┬º┬ºpush(true);
  151.                   }
  152.                   else
  153.                   {
  154.                      if(eval("\x01") == 639)
  155.                      {
  156.                         set("\x01",eval("\x01") + 234);
  157.                         break loop0;
  158.                      }
  159.                      if(eval("\x01") == 169)
  160.                      {
  161.                         set("\x01",eval("\x01") + 470);
  162.                         if(┬º┬ºpop())
  163.                         {
  164.                            set("\x01",eval("\x01") + 234);
  165.                         }
  166.                      }
  167.                      else if(eval("\x01") == 951)
  168.                      {
  169.                         set("\x01",eval("\x01") - 500);
  170.                         if(┬º┬ºpop())
  171.                         {
  172.                            set("\x01",eval("\x01") + 29);
  173.                         }
  174.                      }
  175.                      else if(eval("\x01") == 71)
  176.                      {
  177.                         set("\x01",eval("\x01") + 880);
  178.                         ┬º┬ºpush(true);
  179.                      }
  180.                      else
  181.                      {
  182.                         if(eval("\x01") == 997)
  183.                         {
  184.                            set("\x01",eval("\x01") - 791);
  185.                            ┬º┬ºpush(String(int(┬º┬ºpop())));
  186.                            break loop0;
  187.                         }
  188.                         if(eval("\x01") == 910)
  189.                         {
  190.                            set("\x01",eval("\x01") + 31);
  191.                            if(┬º┬ºpop())
  192.                            {
  193.                               set("\x01",eval("\x01") - 870);
  194.                            }
  195.                         }
  196.                         else if(eval("\x01") == 206)
  197.                         {
  198.                            set("\x01",eval("\x01") + 704);
  199.                            ┬º┬ºpush(true);
  200.                         }
  201.                         else if(eval("\x01") == 518)
  202.                         {
  203.                            set("\x01",eval("\x01") - 163);
  204.                            if(┬º┬ºpop())
  205.                            {
  206.                               set("\x01",eval("\x01") - 224);
  207.                            }
  208.                         }
  209.                         else if(eval("\x01") == 480)
  210.                         {
  211.                            set("\x01",eval("\x01") + 172);
  212.                            ┬º┬ºpush(true);
  213.                         }
  214.                         else
  215.                         {
  216.                            if(eval("\x01") == 229)
  217.                            {
  218.                               set("\x01",eval("\x01") - 229);
  219.                               break loop0;
  220.                            }
  221.                            if(eval("\x01") == 941)
  222.                            {
  223.                               set("\x01",eval("\x01") - 870);
  224.                               break loop0;
  225.                            }
  226.                            if(eval("\x01") == 328)
  227.                            {
  228.                               set("\x01",eval("\x01") + 190);
  229.                               ┬º┬ºpush(true);
  230.                            }
  231.                            else
  232.                            {
  233.                               if(eval("\x01") == 158)
  234.                               {
  235.                                  set("\x01",eval("\x01") + 170);
  236.                                  break loop0;
  237.                               }
  238.                               if(eval("\x01") != 250)
  239.                               {
  240.                                  break loop0;
  241.                               }
  242.                               set("\x01",eval("\x01") - 92);
  243.                               if(┬º┬ºpop())
  244.                               {
  245.                                  set("\x01",eval("\x01") + 170);
  246.                               }
  247.                            }
  248.                         }
  249.                      }
  250.                   }
  251.                }
  252.             }
  253.          }
  254.          while(true)
  255.          {
  256.             if(eval("\x01") == 502)
  257.             {
  258.                set("\x01",eval("\x01") - 252);
  259.                ┬º┬ºpush(true);
  260.                continue;
  261.             }
  262.             if(eval("\x01") == 873)
  263.             {
  264.                set("\x01",eval("\x01") - 644);
  265.                this.removeMovieClip();
  266.                break loop0;
  267.             }
  268.             if(eval("\x01") == 81)
  269.             {
  270.                set("\x01",eval("\x01") + 832);
  271.                if(┬º┬ºpop())
  272.                {
  273.                   set("\x01",eval("\x01") - 533);
  274.                }
  275.                continue;
  276.             }
  277.             if(eval("\x01") == 131)
  278.             {
  279.                set("\x01",eval("\x01") - 50);
  280.                ┬º┬ºpush(true);
  281.                continue;
  282.             }
  283.             if(eval("\x01") == 704)
  284.             {
  285.                set("\x01",eval("\x01") - 132);
  286.                ┬º┬ºpush(true);
  287.                continue;
  288.             }
  289.             if(eval("\x01") != 913)
  290.             {
  291.                if(eval("\x01") != 380)
  292.                {
  293.                   break;
  294.                }
  295.                set("\x01",eval("\x01") + 606);
  296.                ┬º┬ºpush(true);
  297.                continue;
  298.             }
  299.             set("\x01",eval("\x01") - 533);
  300.             while(true)
  301.             {
  302.                if(┬º┬ºpop() == 250)
  303.                {
  304.                   set("\x01",eval("\x01") - 98);
  305.                   break loop0;
  306.                }
  307.                if(eval("\x01") != 152)
  308.                {
  309.                   if(eval("\x01") == 998)
  310.                   {
  311.                      set("\x01",eval("\x01") - 998);
  312.                   }
  313.                   break loop0;
  314.                }
  315.                set("\x01",eval("\x01") + 764);
  316.                ┬º┬ºpush(true);
  317.                while(true)
  318.                {
  319.                   if(eval("\x01") == 81)
  320.                   {
  321.                      set("\x01",eval("\x01") + 802);
  322.                      ┬º┬ºpush(true);
  323.                   }
  324.                   else if(eval("\x01") == 883)
  325.                   {
  326.                      set("\x01",eval("\x01") - 123);
  327.                      if(┬º┬ºpop())
  328.                      {
  329.                         set("\x01",eval("\x01") - 59);
  330.                      }
  331.                   }
  332.                   else
  333.                   {
  334.                      if(eval("\x01") == 227)
  335.                      {
  336.                         set("\x01",eval("\x01") + 396);
  337.                         break loop0;
  338.                      }
  339.                      if(eval("\x01") == 623)
  340.                      {
  341.                         set("\x01",eval("\x01") + 375);
  342.                         removeMovieClip(this);
  343.                         break loop0;
  344.                      }
  345.                      if(eval("\x01") == 592)
  346.                      {
  347.                         set("\x01",eval("\x01") - 342);
  348.                         if(┬º┬ºpop())
  349.                         {
  350.                            set("\x01",eval("\x01") - 98);
  351.                         }
  352.                      }
  353.                      else
  354.                      {
  355.                         if(eval("\x01") == 760)
  356.                         {
  357.                            set("\x01",eval("\x01") - 59);
  358.                            break loop0;
  359.                         }
  360.                         if(eval("\x01") == 916)
  361.                         {
  362.                            set("\x01",eval("\x01") - 689);
  363.                            if(┬º┬ºpop())
  364.                            {
  365.                               set("\x01",eval("\x01") + 396);
  366.                            }
  367.                         }
  368.                         else
  369.                         {
  370.                            if(eval("\x01") != 701)
  371.                            {
  372.                               break;
  373.                            }
  374.                            set("\x01",eval("\x01") - 109);
  375.                            ┬º┬ºpush(true);
  376.                         }
  377.                      }
  378.                   }
  379.                }
  380.             }
  381.          }
  382.       }
  383.    }
  384.    else
  385.    {
  386.       if(eval("\x01") == 487)
  387.       {
  388.          set("\x01",eval("\x01") - 113);
  389.          if(┬º┬ºpop())
  390.          {
  391.             set("\x01",eval("\x01") + 30);
  392.          }
  393.          continue;
  394.       }
  395.       if(eval("\x01") == 732)
  396.       {
  397.          set("\x01",eval("\x01") + 225);
  398.          break;
  399.       }
  400.       if(eval("\x01") == 695)
  401.       {
  402.          set("\x01",eval("\x01") - 54);
  403.          break;
  404.       }
  405.       if(eval("\x01") == 257)
  406.       {
  407.          set("\x01",eval("\x01") + 48);
  408.          break;
  409.       }
  410.       if(eval("\x01") == 290)
  411.       {
  412.          set("\x01",eval("\x01") + 81);
  413.          ┬º┬ºpush(new ┬º\┬º\┬ºpop()┬º());
  414.          break;
  415.       }
  416.       if(eval("\x01") == 305)
  417.       {
  418.          set("\x01",eval("\x01") + 364);
  419.          if(_root.oiRapite != _root.oiTarget)
  420.          {
  421.             _root.goodJob.gotoAndPlay("end");
  422.          }
  423.          break;
  424.       }
  425.       if(eval("\x01") == 581)
  426.       {
  427.          set("\x01",eval("\x01") + 151);
  428.          if(┬º┬ºpop())
  429.          {
  430.             set("\x01",eval("\x01") + 225);
  431.          }
  432.          continue;
  433.       }
  434.       if(eval("\x01") == 641)
  435.       {
  436.          set("\x01",eval("\x01") - 60);
  437.          ┬º┬ºpush(true);
  438.          continue;
  439.       }
  440.       if(eval("\x01") != 374)
  441.       {
  442.          if(eval("\x01") == 669)
  443.          {
  444.             set("\x01",eval("\x01") - 669);
  445.          }
  446.          break;
  447.       }
  448.       set("\x01",eval("\x01") + 30);
  449.       while(true)
  450.       {
  451.          if(!┬º┬ºpop())
  452.          {
  453.             set("\x01",eval("\x01") - 938);
  454.             if(┬º┬ºpop())
  455.             {
  456.                set("\x01",eval("\x01") + 546);
  457.             }
  458.          }
  459.          else
  460.          {
  461.             if(eval("\x01") == 43)
  462.             {
  463.                set("\x01",eval("\x01") + 546);
  464.                break loop0;
  465.             }
  466.             if(eval("\x01") == 579)
  467.             {
  468.                set("\x01",eval("\x01") - 564);
  469.                ┬º┬ºpush(true);
  470.             }
  471.             else if(eval("\x01") == 210)
  472.             {
  473.                set("\x01",eval("\x01") - 100);
  474.                ┬º┬ºpush(true);
  475.             }
  476.             else if(eval("\x01") == 639)
  477.             {
  478.                set("\x01",eval("\x01") - 133);
  479.                if(┬º┬ºpop())
  480.                {
  481.                   set("\x01",eval("\x01") - 245);
  482.                }
  483.             }
  484.             else
  485.             {
  486.                if(eval("\x01") == 486)
  487.                {
  488.                   set("\x01",eval("\x01") + 456);
  489.                   loop11:
  490.                   while(true)
  491.                   {
  492.                      if(!┬º┬ºpop())
  493.                      {
  494.                         set("\x01",eval("\x01") - 705);
  495.                         ┬º┬ºpush(true);
  496.                      }
  497.                      else
  498.                      {
  499.                         if(eval("\x01") == 519)
  500.                         {
  501.                            set("\x01",eval("\x01") - 328);
  502.                            nextFrame();
  503.                            toggleHighQuality();
  504.                            nextFrame();
  505.                            toggleHighQuality();
  506.                            ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop()[┬º┬ºpop()] + 0.5;
  507.                            this.end += this.oiRapite;
  508.                         }
  509.                         else
  510.                         {
  511.                            if(eval("\x01") == 69)
  512.                            {
  513.                               set("\x01",eval("\x01") + 897);
  514.                               addr513:
  515.                               ┬º┬ºpush(true);
  516.                               while(true)
  517.                               {
  518.                                  if(eval("\x01") == 911)
  519.                                  {
  520.                                     set("\x01",eval("\x01") - 662);
  521.                                     ┬º┬ºpush(true);
  522.                                     continue;
  523.                                  }
  524.                                  if(eval("\x01") == 77)
  525.                                  {
  526.                                     set("\x01",eval("\x01") + 703);
  527.                                     ┬º┬ºpush(true);
  528.                                     continue;
  529.                                  }
  530.                                  if(eval("\x01") == 218)
  531.                                  {
  532.                                     set("\x01",eval("\x01") + 604);
  533.                                     break loop0;
  534.                                  }
  535.                                  if(eval("\x01") == 249)
  536.                                  {
  537.                                     set("\x01",eval("\x01") + 208);
  538.                                     if(┬º┬ºpop())
  539.                                     {
  540.                                        set("\x01",eval("\x01") - 388);
  541.                                     }
  542.                                     continue;
  543.                                  }
  544.                                  if(eval("\x01") == 971)
  545.                                  {
  546.                                     set("\x01",eval("\x01") - 582);
  547.                                     ┬º┬ºpush(true);
  548.                                     continue;
  549.                                  }
  550.                                  if(eval("\x01") == 966)
  551.                                  {
  552.                                     set("\x01",eval("\x01") - 21);
  553.                                     if(┬º┬ºpop())
  554.                                     {
  555.                                        set("\x01",eval("\x01") + 26);
  556.                                     }
  557.                                     continue;
  558.                                  }
  559.                                  if(eval("\x01") == 457)
  560.                                  {
  561.                                     set("\x01",eval("\x01") - 388);
  562.                                     break loop0;
  563.                                  }
  564.                                  if(eval("\x01") == 26)
  565.                                  {
  566.                                     set("\x01",eval("\x01") + 192);
  567.                                     if(┬º┬ºpop())
  568.                                     {
  569.                                        set("\x01",eval("\x01") + 604);
  570.                                     }
  571.                                     continue;
  572.                                  }
  573.                                  if(eval("\x01") == 191)
  574.                                  {
  575.                                     set("\x01",eval("\x01") + 16);
  576.                                     this.speed = 1;
  577.                                     this.onEnterFrame = function()
  578.                                     {
  579.                                        if(this._y <= 550)
  580.                                        {
  581.                                           this.speed += 0.5;
  582.                                           this._y += this.speed;
  583.                                        }
  584.                                        else
  585.                                        {
  586.                                           this.removeMovieClip();
  587.                                        }
  588.                                     };
  589.                                     break loop0;
  590.                                  }
  591.                                  continue loop11;
  592.                               }
  593.                               addr513:
  594.                            }
  595.                            else
  596.                            {
  597.                               if(eval("\x01") == 76)
  598.                               {
  599.                                  set("\x01",eval("\x01") + 58);
  600.                                  break loop0;
  601.                               }
  602.                               if(eval("\x01") == 17)
  603.                               {
  604.                                  set("\x01",eval("\x01") + 336);
  605.                                  ┬º┬ºgoto(addr513);
  606.                                  ┬º┬ºpush(true);
  607.                               }
  608.                               else
  609.                               {
  610.                                  if(eval("\x01") == 945)
  611.                                  {
  612.                                     set("\x01",eval("\x01") + 26);
  613.                                     prevFrame();
  614.                                     addr51:
  615.                                     if(eval("\x01") == 104)
  616.                                     {
  617.                                        set("\x01",eval("\x01") + 144);
  618.                                        ┬º┬ºgoto(addr51);
  619.                                        ┬º┬ºpush(true);
  620.                                     }
  621.                                     if(eval("\x01") == 984)
  622.                                     {
  623.                                        set("\x01",eval("\x01") - 433);
  624.                                        ┬º┬ºgoto(addr51);
  625.                                        ┬º┬ºpush(true);
  626.                                     }
  627.                                     if(eval("\x01") == 712)
  628.                                     {
  629.                                        set("\x01",eval("\x01") - 293);
  630.                                        if(!┬º┬ºpop())
  631.                                        {
  632.                                           addr102:
  633.                                           ┬º┬ºgoto(addr51);
  634.                                        }
  635.                                        set("\x01",eval("\x01") - 76);
  636.                                        ┬º┬ºgoto(addr102);
  637.                                     }
  638.                                     addr375:
  639.                                     if(eval("\x01") != 178)
  640.                                     {
  641.                                        if(eval("\x01") == 248)
  642.                                        {
  643.                                           set("\x01",eval("\x01") + 228);
  644.                                           if(!┬º┬ºpop())
  645.                                           {
  646.                                              addr136:
  647.                                              ┬º┬ºgoto(addr51);
  648.                                           }
  649.                                           set("\x01",eval("\x01") - 457);
  650.                                           ┬º┬ºgoto(addr136);
  651.                                        }
  652.                                        if(eval("\x01") == 963)
  653.                                        {
  654.                                           set("\x01",eval("\x01") - 471);
  655.                                           if(!┬º┬ºpop())
  656.                                           {
  657.                                              addr157:
  658.                                              ┬º┬ºgoto(addr51);
  659.                                           }
  660.                                           set("\x01",eval("\x01") + 146);
  661.                                           ┬º┬ºgoto(addr157);
  662.                                        }
  663.                                        if(eval("\x01") != 492)
  664.                                        {
  665.                                           if(eval("\x01") == 682)
  666.                                           {
  667.                                              set("\x01",eval("\x01") + 281);
  668.                                              ┬º┬ºgoto(addr51);
  669.                                              ┬º┬ºpush(true);
  670.                                           }
  671.                                           if(eval("\x01") == 198)
  672.                                           {
  673.                                              set("\x01",eval("\x01") + 514);
  674.                                              ┬º┬ºgoto(addr51);
  675.                                              ┬º┬ºpush(true);
  676.                                           }
  677.                                           if(eval("\x01") != 419)
  678.                                           {
  679.                                              if(eval("\x01") == 551)
  680.                                              {
  681.                                                 set("\x01",eval("\x01") - 373);
  682.                                                 if(!┬º┬ºpop())
  683.                                                 {
  684.                                                    addr232:
  685.                                                    ┬º┬ºgoto(addr51);
  686.                                                 }
  687.                                                 set("\x01",eval("\x01") + 20);
  688.                                                 ┬º┬ºgoto(addr232);
  689.                                              }
  690.                                              if(eval("\x01") != 424)
  691.                                              {
  692.                                                 if(eval("\x01") != 756)
  693.                                                 {
  694.                                                    if(eval("\x01") == 638)
  695.                                                    {
  696.                                                       set("\x01",eval("\x01") - 186);
  697.                                                       ┬º┬ºgoto(addr51);
  698.                                                       ┬º┬ºpush(true);
  699.                                                    }
  700.                                                    if(eval("\x01") == 194)
  701.                                                    {
  702.                                                       set("\x01",eval("\x01") + 562);
  703.                                                       if(!┬º┬ºpop())
  704.                                                       {
  705.                                                          addr293:
  706.                                                          ┬º┬ºgoto(addr51);
  707.                                                       }
  708.                                                       set("\x01",eval("\x01") - 139);
  709.                                                       ┬º┬ºgoto(addr293);
  710.                                                    }
  711.                                                    if(eval("\x01") != 476)
  712.                                                    {
  713.                                                       if(eval("\x01") == 225)
  714.                                                       {
  715.                                                          set("\x01",eval("\x01") + 199);
  716.                                                          if(!┬º┬ºpop())
  717.                                                          {
  718.                                                             addr327:
  719.                                                             ┬º┬ºgoto(addr51);
  720.                                                          }
  721.                                                          set("\x01",eval("\x01") + 560);
  722.                                                          ┬º┬ºgoto(addr327);
  723.                                                       }
  724.                                                       if(eval("\x01") == 19)
  725.                                                       {
  726.                                                          set("\x01",eval("\x01") + 206);
  727.                                                          ┬º┬ºgoto(addr51);
  728.                                                          ┬º┬ºpush(true);
  729.                                                       }
  730.                                                       if(eval("\x01") != 706)
  731.                                                       {
  732.                                                          if(eval("\x01") == 343)
  733.                                                          {
  734.                                                             set("\x01",eval("\x01") + 313);
  735.                                                             ┬º┬ºgoto(addr375);
  736.                                                             ┬º┬ºpush(true);
  737.                                                          }
  738.                                                          if(eval("\x01") == 656)
  739.                                                          {
  740.                                                             set("\x01",eval("\x01") + 50);
  741.                                                             if(!┬º┬ºpop())
  742.                                                             {
  743.                                                                addr396:
  744.                                                                ┬º┬ºgoto(addr51);
  745.                                                             }
  746.                                                             set("\x01",eval("\x01") - 24);
  747.                                                             ┬º┬ºgoto(addr396);
  748.                                                          }
  749.                                                          if(eval("\x01") == 452)
  750.                                                          {
  751.                                                             set("\x01",eval("\x01") - 355);
  752.                                                             if(!┬º┬ºpop())
  753.                                                             {
  754.                                                                addr417:
  755.                                                                ┬º┬ºgoto(addr51);
  756.                                                             }
  757.                                                             addr415:
  758.                                                             set("\x01",eval("\x01") + 152);
  759.                                                             ┬º┬ºgoto(addr417);
  760.                                                          }
  761.                                                          if(eval("\x01") != 97)
  762.                                                          {
  763.                                                             if(eval("\x01") == 249)
  764.                                                             {
  765.                                                                set("\x01",eval("\x01") - 55);
  766.                                                                ┬º┬ºgoto(addr51);
  767.                                                                ┬º┬ºpush(true);
  768.                                                             }
  769.                                                             if(eval("\x01") == 617)
  770.                                                             {
  771.                                                                set("\x01",eval("\x01") + 103);
  772.                                                                this.speed = 1;
  773.                                                                addr48:
  774.                                                                this.onEnterFrame = function()
  775.                                                                {
  776.                                                                   if(this._y <= 550)
  777.                                                                   {
  778.                                                                      this.speed += 0.5;
  779.                                                                      this.end += this.oiRapite;
  780.                                                                   }
  781.                                                                   else
  782.                                                                   {
  783.                                                                      this.removeMovieClip();
  784.                                                                   }
  785.                                                                };
  786.                                                                break loop0;
  787.                                                             }
  788.                                                             if(eval("\x01") == 720)
  789.                                                             {
  790.                                                                set("\x01",eval("\x01") - 720);
  791.                                                             }
  792.                                                             break loop0;
  793.                                                          }
  794.                                                          addr426:
  795.                                                          set("\x01",eval("\x01") + 152);
  796.                                                          break loop0;
  797.                                                       }
  798.                                                       set("\x01",eval("\x01") - 24);
  799.                                                       break loop0;
  800.                                                    }
  801.                                                    set("\x01",eval("\x01") - 457);
  802.                                                    break loop0;
  803.                                                 }
  804.                                                 set("\x01",eval("\x01") - 139);
  805.                                                 break loop0;
  806.                                              }
  807.                                              set("\x01",eval("\x01") + 560);
  808.                                              break loop0;
  809.                                           }
  810.                                           set("\x01",eval("\x01") - 76);
  811.                                           break loop0;
  812.                                        }
  813.                                        set("\x01",eval("\x01") + 146);
  814.                                        break loop0;
  815.                                     }
  816.                                     set("\x01",eval("\x01") + 20);
  817.                                     ┬º┬ºpush(new ┬º\┬º\┬ºpop()┬º());
  818.                                     break loop0;
  819.                                  }
  820.                                  if(eval("\x01") == 362)
  821.                                  {
  822.                                     set("\x01",eval("\x01") - 345);
  823.                                     break loop0;
  824.                                  }
  825.                                  if(eval("\x01") == 134)
  826.                                  {
  827.                                     set("\x01",eval("\x01") - 108);
  828.                                     ┬º┬ºgoto(addr513);
  829.                                     ┬º┬ºpush(true);
  830.                                  }
  831.                                  else
  832.                                  {
  833.                                     if(eval("\x01") == 117)
  834.                                     {
  835.                                        set("\x01",eval("\x01") + 402);
  836.                                        if(┬º┬ºpop())
  837.                                        {
  838.                                           set("\x01",eval("\x01") - 328);
  839.                                        }
  840.                                     }
  841.                                     else if(eval("\x01") == 389)
  842.                                     {
  843.                                        set("\x01",eval("\x01") - 27);
  844.                                        if(┬º┬ºpop())
  845.                                        {
  846.                                           set("\x01",eval("\x01") - 345);
  847.                                        }
  848.                                        ┬º┬ºgoto(addr513);
  849.                                     }
  850.                                     else if(eval("\x01") == 212)
  851.                                     {
  852.                                        set("\x01",eval("\x01") - 135);
  853.                                     }
  854.                                     else
  855.                                     {
  856.                                        if(eval("\x01") == 207)
  857.                                        {
  858.                                           set("\x01",eval("\x01") - 207);
  859.                                           break loop0;
  860.                                        }
  861.                                        if(eval("\x01") == 780)
  862.                                        {
  863.                                           set("\x01",eval("\x01") - 704);
  864.                                           if(┬º┬ºpop())
  865.                                           {
  866.                                              set("\x01",eval("\x01") + 58);
  867.                                           }
  868.                                        }
  869.                                        else
  870.                                        {
  871.                                           if(eval("\x01") != 353)
  872.                                           {
  873.                                              break loop0;
  874.                                           }
  875.                                           set("\x01",eval("\x01") - 141);
  876.                                           if(┬º┬ºpop())
  877.                                           {
  878.                                              set("\x01",eval("\x01") - 135);
  879.                                           }
  880.                                        }
  881.                                        ┬º┬ºgoto(addr513);
  882.                                     }
  883.                                     ┬º┬ºgoto(addr513);
  884.                                  }
  885.                                  ┬º┬ºgoto(addr513);
  886.                                  ┬º┬ºgoto(addr415);
  887.                               }
  888.                               ┬º┬ºgoto(addr513);
  889.                            }
  890.                            ┬º┬ºgoto(addr513);
  891.                         }
  892.                         ┬º┬ºgoto(addr48);
  893.                      }
  894.                      ┬º┬ºgoto(addr513);
  895.                   }
  896.                }
  897.                else
  898.                {
  899.                   if(eval("\x01") == 506)
  900.                   {
  901.                      set("\x01",eval("\x01") - 245);
  902.                      break loop0;
  903.                   }
  904.                   if(eval("\x01") == 980)
  905.                   {
  906.                      set("\x01",eval("\x01") - 235);
  907.                      break loop0;
  908.                   }
  909.                   if(eval("\x01") == 110)
  910.                   {
  911.                      set("\x01",eval("\x01") + 108);
  912.                      if(┬º┬ºpop())
  913.                      {
  914.                         set("\x01",eval("\x01") - 217);
  915.                      }
  916.                      addr2096:
  917.                      while(true)
  918.                      {
  919.                         if(eval("\x01") == 67)
  920.                         {
  921.                            set("\x01",eval("\x01") + 914);
  922.                            ┬º┬ºpush(true);
  923.                            continue;
  924.                         }
  925.                         if(eval("\x01") == 261)
  926.                         {
  927.                            set("\x01",eval("\x01") + 684);
  928.                            ┬º┬ºpush(true);
  929.                            continue;
  930.                         }
  931.                         if(eval("\x01") == 198)
  932.                         {
  933.                            set("\x01",eval("\x01") + 782);
  934.                            if(┬º┬ºpop())
  935.                            {
  936.                               set("\x01",eval("\x01") - 235);
  937.                            }
  938.                            continue;
  939.                         }
  940.                         if(eval("\x01") == 589)
  941.                         {
  942.                            set("\x01",eval("\x01") + 50);
  943.                            ┬º┬ºpush(true);
  944.                            continue;
  945.                         }
  946.                         if(eval("\x01") == 296)
  947.                         {
  948.                            set("\x01",eval("\x01") + 488);
  949.                            if(┬º┬ºpop())
  950.                            {
  951.                               set("\x01",eval("\x01") - 636);
  952.                            }
  953.                            continue;
  954.                         }
  955.                         if(eval("\x01") == 276)
  956.                         {
  957.                            set("\x01",eval("\x01") + 303);
  958.                            break loop0;
  959.                         }
  960.                         if(eval("\x01") == 15)
  961.                         {
  962.                            set("\x01",eval("\x01") + 471);
  963.                            if(┬º┬ºpop())
  964.                            {
  965.                               set("\x01",eval("\x01") + 456);
  966.                            }
  967.                            continue;
  968.                         }
  969.                         if(eval("\x01") != 218)
  970.                         {
  971.                            if(eval("\x01") == 1)
  972.                            {
  973.                               set("\x01",eval("\x01") + 295);
  974.                               ┬º┬ºpush(true);
  975.                            }
  976.                            else
  977.                            {
  978.                               if(eval("\x01") != 745)
  979.                               {
  980.                                  break;
  981.                               }
  982.                               set("\x01",eval("\x01") + 93);
  983.                               ┬º┬ºpush(true);
  984.                            }
  985.                            continue;
  986.                         }
  987.                         set("\x01",eval("\x01") - 217);
  988.                         while(true)
  989.                         {
  990.                            if(┬º┬ºpop() == ┬º┬ºpop())
  991.                            {
  992.                               set("\x01",eval("\x01") + 646);
  993.                               ┬º┬ºpush(new ┬º┬ºpop()[┬º┬ºpop()]());
  994.                               break loop0;
  995.                            }
  996.                            if(eval("\x01") == 719)
  997.                            {
  998.                               set("\x01",eval("\x01") - 633);
  999.                               break loop0;
  1000.                            }
  1001.                            if(eval("\x01") == 86)
  1002.                            {
  1003.                               set("\x01",eval("\x01") + 674);
  1004.                               ┬º┬ºpush(true);
  1005.                            }
  1006.                            else if(eval("\x01") == 459)
  1007.                            {
  1008.                               set("\x01",eval("\x01") - 203);
  1009.                               if(┬º┬ºpop())
  1010.                               {
  1011.                                  set("\x01",eval("\x01") + 646);
  1012.                               }
  1013.                            }
  1014.                            else if(eval("\x01") == 149)
  1015.                            {
  1016.                               set("\x01",eval("\x01") + 577);
  1017.                               ┬º┬ºpush(true);
  1018.                            }
  1019.                            else if(eval("\x01") == 384)
  1020.                            {
  1021.                               set("\x01",eval("\x01") - 124);
  1022.                               ┬º┬ºpush(true);
  1023.                            }
  1024.                            else if(eval("\x01") == 132)
  1025.                            {
  1026.                               set("\x01",eval("\x01") + 650);
  1027.                               ┬º┬ºpush(true);
  1028.                            }
  1029.                            else if(eval("\x01") == 760)
  1030.                            {
  1031.                               set("\x01",eval("\x01") + 36);
  1032.                               if(┬º┬ºpop())
  1033.                               {
  1034.                                  set("\x01",eval("\x01") + 77);
  1035.                               }
  1036.                            }
  1037.                            else
  1038.                            {
  1039.                               if(eval("\x01") == 630)
  1040.                               {
  1041.                                  set("\x01",eval("\x01") - 58);
  1042.                                  break loop0;
  1043.                               }
  1044.                               if(eval("\x01") != 73)
  1045.                               {
  1046.                                  if(eval("\x01") == 774)
  1047.                                  {
  1048.                                     set("\x01",eval("\x01") - 774);
  1049.                                  }
  1050.                                  break loop0;
  1051.                               }
  1052.                               set("\x01",eval("\x01") + 58);
  1053.                               if(┬º┬ºpop())
  1054.                               {
  1055.                                  set("\x01",eval("\x01") + 18);
  1056.                               }
  1057.                            }
  1058.                            while(true)
  1059.                            {
  1060.                               if(eval("\x01") == 454)
  1061.                               {
  1062.                                  set("\x01",eval("\x01") - 381);
  1063.                                  ┬º┬ºpush(true);
  1064.                                  continue;
  1065.                               }
  1066.                               if(eval("\x01") == 254)
  1067.                               {
  1068.                                  set("\x01",eval("\x01") - 122);
  1069.                                  break loop0;
  1070.                               }
  1071.                               if(eval("\x01") == 203)
  1072.                               {
  1073.                                  set("\x01",eval("\x01") - 156);
  1074.                                  if(┬º┬ºpop())
  1075.                                  {
  1076.                                     set("\x01",eval("\x01") + 75);
  1077.                                  }
  1078.                                  continue;
  1079.                               }
  1080.                               if(eval("\x01") == 131)
  1081.                               {
  1082.                                  set("\x01",eval("\x01") + 18);
  1083.                                  ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  1084.                                  break loop0;
  1085.                               }
  1086.                               if(eval("\x01") == 567)
  1087.                               {
  1088.                                  set("\x01",eval("\x01") - 263);
  1089.                                  stop();
  1090.                                  ┬º┬ºpush(┬º┬ºpop() ^ ┬º┬ºpop());
  1091.                                  break loop0;
  1092.                               }
  1093.                               if(eval("\x01") != 748)
  1094.                               {
  1095.                                  if(eval("\x01") == 304)
  1096.                                  {
  1097.                                     set("\x01",eval("\x01") + 463);
  1098.                                     ┬º┬ºpush(true);
  1099.                                  }
  1100.                                  else if(eval("\x01") == 67)
  1101.                                  {
  1102.                                     set("\x01",eval("\x01") + 392);
  1103.                                     ┬º┬ºpush(true);
  1104.                                  }
  1105.                                  else if(eval("\x01") == 122)
  1106.                                  {
  1107.                                     set("\x01",eval("\x01") + 685);
  1108.                                     ┬º┬ºpush(true);
  1109.                                  }
  1110.                                  else if(eval("\x01") == 726)
  1111.                                  {
  1112.                                     set("\x01",eval("\x01") - 159);
  1113.                                     if(┬º┬ºpop())
  1114.                                     {
  1115.                                        set("\x01",eval("\x01") - 263);
  1116.                                     }
  1117.                                  }
  1118.                                  else if(eval("\x01") == 902)
  1119.                                  {
  1120.                                     set("\x01",eval("\x01") - 699);
  1121.                                     ┬º┬ºpush(true);
  1122.                                  }
  1123.                                  else if(eval("\x01") == 782)
  1124.                                  {
  1125.                                     set("\x01",eval("\x01") - 63);
  1126.                                     if(┬º┬ºpop())
  1127.                                     {
  1128.                                        set("\x01",eval("\x01") - 633);
  1129.                                     }
  1130.                                  }
  1131.                                  else
  1132.                                  {
  1133.                                     if(eval("\x01") == 969)
  1134.                                     {
  1135.                                        set("\x01",eval("\x01") - 585);
  1136.                                        stop();
  1137.                                        ┬º┬ºpush(int(┬º┬ºpop()));
  1138.                                        break loop0;
  1139.                                     }
  1140.                                     if(eval("\x01") == 47)
  1141.                                     {
  1142.                                        set("\x01",eval("\x01") + 75);
  1143.                                        break loop0;
  1144.                                     }
  1145.                                     if(eval("\x01") == 807)
  1146.                                     {
  1147.                                        set("\x01",eval("\x01") - 553);
  1148.                                        if(┬º┬ºpop())
  1149.                                        {
  1150.                                           set("\x01",eval("\x01") - 122);
  1151.                                        }
  1152.                                     }
  1153.                                     else
  1154.                                     {
  1155.                                        if(eval("\x01") == 572)
  1156.                                        {
  1157.                                           set("\x01",eval("\x01") + 202);
  1158.                                           _parent.gotoAndPlay("remove");
  1159.                                           break loop0;
  1160.                                        }
  1161.                                        if(eval("\x01") == 816)
  1162.                                        {
  1163.                                           set("\x01",eval("\x01") + 153);
  1164.                                           if(┬º┬ºpop())
  1165.                                           {
  1166.                                              set("\x01",eval("\x01") - 585);
  1167.                                           }
  1168.                                        }
  1169.                                        else if(eval("\x01") == 767)
  1170.                                        {
  1171.                                           set("\x01",eval("\x01") - 19);
  1172.                                           if(┬º┬ºpop())
  1173.                                           {
  1174.                                              set("\x01",eval("\x01") - 681);
  1175.                                           }
  1176.                                        }
  1177.                                        else
  1178.                                        {
  1179.                                           if(eval("\x01") == 796)
  1180.                                           {
  1181.                                              set("\x01",eval("\x01") + 77);
  1182.                                              tellTarget(length(┬º┬ºpop()))
  1183.                                              {
  1184.                                                 break loop0;
  1185.                                              }
  1186.                                           }
  1187.                                           if(eval("\x01") == 873)
  1188.                                           {
  1189.                                              set("\x01",eval("\x01") - 57);
  1190.                                              ┬º┬ºpush(true);
  1191.                                           }
  1192.                                           else
  1193.                                           {
  1194.                                              if(eval("\x01") != 260)
  1195.                                              {
  1196.                                                 break;
  1197.                                              }
  1198.                                              set("\x01",eval("\x01") + 370);
  1199.                                              if(┬º┬ºpop())
  1200.                                              {
  1201.                                                 set("\x01",eval("\x01") - 58);
  1202.                                              }
  1203.                                           }
  1204.                                        }
  1205.                                     }
  1206.                                  }
  1207.                                  continue;
  1208.                               }
  1209.                               set("\x01",eval("\x01") - 681);
  1210.                               loop9:
  1211.                               while(true)
  1212.                               {
  1213.                                  set(┬º┬ºpop(),┬º┬ºpop());
  1214.                                  if(┬º┬ºpop())
  1215.                                  {
  1216.                                     set("\x01",eval("\x01") - 145);
  1217.                                  }
  1218.                                  while(true)
  1219.                                  {
  1220.                                     if(eval("\x01") == 77)
  1221.                                     {
  1222.                                        set("\x01",eval("\x01") + 729);
  1223.                                        ┬º┬ºpush(true);
  1224.                                     }
  1225.                                     else if(eval("\x01") == 219)
  1226.                                     {
  1227.                                        set("\x01",eval("\x01") + 80);
  1228.                                        if(┬º┬ºpop())
  1229.                                        {
  1230.                                           set("\x01",eval("\x01") + 155);
  1231.                                        }
  1232.                                     }
  1233.                                     else if(eval("\x01") == 727)
  1234.                                     {
  1235.                                        set("\x01",eval("\x01") + 212);
  1236.                                        ┬º┬ºpush(true);
  1237.                                     }
  1238.                                     else
  1239.                                     {
  1240.                                        if(eval("\x01") == 806)
  1241.                                        {
  1242.                                           break;
  1243.                                        }
  1244.                                        if(eval("\x01") == 872)
  1245.                                        {
  1246.                                           set("\x01",eval("\x01") - 145);
  1247.                                           setProperty(┬º┬ºpop(), _X, ┬º┬ºpop());
  1248.                                           break loop0;
  1249.                                        }
  1250.                                        if(eval("\x01") == 347)
  1251.                                        {
  1252.                                           set("\x01",eval("\x01") - 45);
  1253.                                           if(┬º┬ºpop())
  1254.                                           {
  1255.                                              set("\x01",eval("\x01") + 558);
  1256.                                           }
  1257.                                        }
  1258.                                        else if(eval("\x01") == 106)
  1259.                                        {
  1260.                                           set("\x01",eval("\x01") + 113);
  1261.                                           ┬º┬ºpush(true);
  1262.                                        }
  1263.                                        else if(eval("\x01") == 69)
  1264.                                        {
  1265.                                           set("\x01",eval("\x01") + 300);
  1266.                                           if(┬º┬ºpop())
  1267.                                           {
  1268.                                              set("\x01",eval("\x01") - 225);
  1269.                                           }
  1270.                                        }
  1271.                                        else if(eval("\x01") == 238)
  1272.                                        {
  1273.                                           set("\x01",eval("\x01") + 315);
  1274.                                           ┬º┬ºpush(true);
  1275.                                        }
  1276.                                        else if(eval("\x01") == 136)
  1277.                                        {
  1278.                                           set("\x01",eval("\x01") - 77);
  1279.                                           if(┬º┬ºpop())
  1280.                                           {
  1281.                                              set("\x01",eval("\x01") + 294);
  1282.                                           }
  1283.                                        }
  1284.                                        else
  1285.                                        {
  1286.                                           if(eval("\x01") == 299)
  1287.                                           {
  1288.                                              set("\x01",eval("\x01") + 155);
  1289.                                              break loop0;
  1290.                                           }
  1291.                                           if(eval("\x01") == 939)
  1292.                                           {
  1293.                                              set("\x01",eval("\x01") - 503);
  1294.                                              if(┬º┬ºpop())
  1295.                                              {
  1296.                                                 set("\x01",eval("\x01") - 288);
  1297.                                              }
  1298.                                           }
  1299.                                           else if(eval("\x01") == 454)
  1300.                                           {
  1301.                                              set("\x01",eval("\x01") - 318);
  1302.                                              ┬º┬ºpush(true);
  1303.                                           }
  1304.                                           else
  1305.                                           {
  1306.                                              if(eval("\x01") == 436)
  1307.                                              {
  1308.                                                 break loop9;
  1309.                                              }
  1310.                                              if(eval("\x01") == 148)
  1311.                                              {
  1312.                                                 set("\x01",eval("\x01") + 199);
  1313.                                                 ┬º┬ºpush(true);
  1314.                                              }
  1315.                                              else if(eval("\x01") == 860)
  1316.                                              {
  1317.                                                 set("\x01",eval("\x01") + 3);
  1318.                                                 ┬º┬ºpush(true);
  1319.                                              }
  1320.                                              else
  1321.                                              {
  1322.                                                 if(eval("\x01") == 696)
  1323.                                                 {
  1324.                                                    set("\x01",eval("\x01") - 590);
  1325.                                                    break loop0;
  1326.                                                 }
  1327.                                                 if(eval("\x01") == 553)
  1328.                                                 {
  1329.                                                    set("\x01",eval("\x01") + 143);
  1330.                                                    if(┬º┬ºpop())
  1331.                                                    {
  1332.                                                       set("\x01",eval("\x01") - 590);
  1333.                                                    }
  1334.                                                 }
  1335.                                                 else
  1336.                                                 {
  1337.                                                    if(eval("\x01") == 302)
  1338.                                                    {
  1339.                                                       set("\x01",eval("\x01") + 558);
  1340.                                                       break loop0;
  1341.                                                    }
  1342.                                                    if(eval("\x01") == 353)
  1343.                                                    {
  1344.                                                       set("\x01",eval("\x01") - 284);
  1345.                                                       ┬º┬ºpush(true);
  1346.                                                    }
  1347.                                                    else
  1348.                                                    {
  1349.                                                       if(eval("\x01") != 863)
  1350.                                                       {
  1351.                                                          if(eval("\x01") == 585)
  1352.                                                          {
  1353.                                                             set("\x01",eval("\x01") - 347);
  1354.                                                             break loop0;
  1355.                                                          }
  1356.                                                          if(eval("\x01") == 59)
  1357.                                                          {
  1358.                                                             set("\x01",eval("\x01") + 294);
  1359.                                                             ┬º┬ºpush(mbchr(┬º┬ºpop()));
  1360.                                                             break loop0;
  1361.                                                          }
  1362.                                                          if(eval("\x01") == 369)
  1363.                                                          {
  1364.                                                             set("\x01",eval("\x01") - 225);
  1365.                                                             break loop0;
  1366.                                                          }
  1367.                                                          if(eval("\x01") == 144)
  1368.                                                          {
  1369.                                                             set("\x01",eval("\x01") - 132);
  1370.                                                             this.speed = 1;
  1371.                                                             this.onEnterFrame = function()
  1372.                                                             {
  1373.                                                                if(this._y <= 550)
  1374.                                                                {
  1375.                                                                   this.speed += 0.5;
  1376.                                                                   this._y += this.speed;
  1377.                                                                }
  1378.                                                                else
  1379.                                                                {
  1380.                                                                   this.removeMovieClip();
  1381.                                                                }
  1382.                                                             };
  1383.                                                             break loop0;
  1384.                                                          }
  1385.                                                          if(eval("\x01") == 12)
  1386.                                                          {
  1387.                                                             set("\x01",eval("\x01") - 12);
  1388.                                                          }
  1389.                                                          break loop0;
  1390.                                                       }
  1391.                                                       set("\x01",eval("\x01") - 278);
  1392.                                                       if(┬º┬ºpop())
  1393.                                                       {
  1394.                                                          set("\x01",eval("\x01") - 347);
  1395.                                                       }
  1396.                                                    }
  1397.                                                 }
  1398.                                              }
  1399.                                           }
  1400.                                        }
  1401.                                     }
  1402.                                  }
  1403.                               }
  1404.                               set("\x01",eval("\x01") - 288);
  1405.                            }
  1406.                         }
  1407.                      }
  1408.                      continue;
  1409.                      addr2096:
  1410.                   }
  1411.                   else
  1412.                   {
  1413.                      if(eval("\x01") == 945)
  1414.                      {
  1415.                         set("\x01",eval("\x01") - 669);
  1416.                         if(┬º┬ºpop())
  1417.                         {
  1418.                            set("\x01",eval("\x01") + 303);
  1419.                         }
  1420.                      }
  1421.                      else
  1422.                      {
  1423.                         if(eval("\x01") == 784)
  1424.                         {
  1425.                            set("\x01",eval("\x01") - 636);
  1426.                            break loop0;
  1427.                         }
  1428.                         if(eval("\x01") == 799)
  1429.                         {
  1430.                            set("\x01",eval("\x01") - 589);
  1431.                            break loop0;
  1432.                         }
  1433.                         if(eval("\x01") == 942)
  1434.                         {
  1435.                            set("\x01",eval("\x01") - 744);
  1436.                            ┬º┬ºgoto(addr2096);
  1437.                            ┬º┬ºpush(true);
  1438.                         }
  1439.                         else
  1440.                         {
  1441.                            if(eval("\x01") != 838)
  1442.                            {
  1443.                               if(eval("\x01") == 148)
  1444.                               {
  1445.                                  set("\x01",eval("\x01") - 51);
  1446.                                  _parent.gotoAndPlay("remove");
  1447.                                  break loop0;
  1448.                               }
  1449.                               if(eval("\x01") == 97)
  1450.                               {
  1451.                                  set("\x01",eval("\x01") - 97);
  1452.                               }
  1453.                               break loop0;
  1454.                            }
  1455.                            set("\x01",eval("\x01") - 39);
  1456.                            if(┬º┬ºpop())
  1457.                            {
  1458.                               set("\x01",eval("\x01") - 589);
  1459.                            }
  1460.                            ┬º┬ºgoto(addr2096);
  1461.                         }
  1462.                      }
  1463.                      ┬º┬ºgoto(addr2096);
  1464.                   }
  1465.                   ┬º┬ºgoto(addr2096);
  1466.                }
  1467.                ┬º┬ºgoto(addr426);
  1468.             }
  1469.          }
  1470.          ┬º┬ºgoto(addr2096);
  1471.       }
  1472.    }
  1473. }
  1474.